关于java反射为属性赋值的问题

引用来自“canghailan”的答案

?

package canghailan.reflect;
 
import canghailan.cache.ConcurrentLRUCache;
 
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
 
/**
 * <a href="http://my.oschina.net/arthor" class="referer" target="_blank">@author</a> canghailan 2012-01-13 23:06
 */
public class Methods {
 
    private static Map<MethodID, Method[]> methodsCache = new ConcurrentLRUCache<>();
    private static ThreadLocal<MethodID> methodID = new ThreadLocal<MethodID>() {
        protected MethodID initialValue() {
            return new MethodID();
        }
    };
 
    //################################################################################
 
    public static Method[] lookupMethods(Class<?> clazz, String name) {
        Method[] methods = methodsCache.get(methodID.get().set(clazz, name));
        if (methods == null) {
            // methods has the same name
            List<Method> list = new LinkedList<>();
            for (Method method : clazz.getMethods()) {
                if (method.getName().equals(name)) {
                    list.add(method);
                }
            }
            methods = list.toArray(new Method[list.size()]);
            // sort by param length
            Arrays.sort(methods,
                    new Comparator<Method>() {
                        @Override
                        public int compare(Method a, Method b) {
                            return a.getParameterTypes().length - b.getParameterTypes().length;
                        }
                    });
            // cache
            methodsCache.put(new MethodID(clazz, name), methods);
        }
        return methods;
    }
 
    public static Method lookupMethod(Class<?> clazz, String name, Object... params)
            throws NoSuchMethodException {
        Method acceptMethod = null;
        for (Method method : lookupMethods(clazz, name)) {
            // skip methods
            if (method.getParameterTypes().length < params.length) {
                continue;
            }
            // lookup finished
            if (method.getParameterTypes().length > params.length) {
                break;
            }
            int diff = checkAssignable(method.getParameterTypes(), params);
            // not match
            if (diff < 0) {
                continue;
            }
            if (diff == 0) {
                return method;
            }
            // better method
            if (acceptMethod == null ||
                    checkAssignable(acceptMethod.getParameterTypes(), method.getParameterTypes()) > 0) {
                acceptMethod = method;
            }
        }
        if (acceptMethod == null) {
            throw new NoSuchMethodException(invokeToString(clazz, name, params));
        }
        return acceptMethod;
    }
 
    private static int checkAssignable(Class<?> type, Class<?> clazz) {
        if (clazz == null || type.equals(clazz)) {
            return 0;
        }
        if (type.isAssignableFrom(clazz)) {
            return 1;
        }
        return -1;
    }
 
    private static int checkAssignable(Class<?>[] types, Class<?>[] classes) {
        if (classes == null || types.length != classes.length) {
            return -1;
        }
        int diffs = 0;
        for (int i = 0; i < classes.length; ++i) {
            int diff = checkAssignable(types[i], classes[i]);
            if (diff < 0) {
                return -1;
            }
            diffs += diff;
        }
        return diffs;
    }
 
    private static int checkAssignable(Class<?>[] classes, Object[] objects) {
        if (objects == null || classes.length != objects.length) {
            return -1;
        }
        int diffs = 0;
        for (int i = 0; i < classes.length; ++i) {
            int diff = checkAssignable(classes[i],
                    objects[i] == null ? null : objects[i].getClass());
            if (diff < 0) {
                return -1;
            }
            diffs += diff;
        }
        return diffs;
    }
 
    private static String invokeToString(Class<?> clazz, String method, Object... params) {
        StringBuilder buffer = new StringBuilder();
        buffer.append(clazz.getName()).append('$');
        buffer.append(method).append('(');
        for (Object param : params) {
            buffer.append(param).append(", ");
        }
        buffer.setLength(buffer.length() - ", ".length());
        buffer.append(')');
        return buffer.toString();
    }
 
    //################################################################################
 
    @SuppressWarnings("unchecked")
    public static <T> T invoke(Object object, String method, Object... params)
            throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        return (T) lookupMethod(object.getClass(), method, params).invoke(object, params);
    }
 
 
    @SuppressWarnings("unchecked")
    public static <T> T invoke(Class<?> clazz, String method, Object... params)
            throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        return (T) lookupMethod(clazz, method, params).invoke(null, params);
    }
 
    //################################################################################
 
    private static class MethodID {
        Class<?> clazz;
        String name;
 
        MethodID() {
        }
 
        MethodID(Class<?> clazz, String name) {
            this.clazz = clazz;
            this.name = name;
        }
 
        MethodID set(Class<?> clazz, String name) {
            this.clazz = clazz;
            this.name = name;
            return this;
        }
 
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o instanceof MethodID) {
                MethodID methodID = (MethodID) o;
                return Objects.equals(clazz, methodID.clazz) &&
                        Objects.equals(name, methodID.name);
            }
            return false;
        }
 
        @Override
        public int hashCode() {
            int result = Objects.hashCode(clazz);
            result = 31 * result + Objects.hashCode(name);
            return result;
        }
    }
}

?

package canghailan.reflect;
 
import canghailan.cache.ConcurrentLRUCache;
 
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Objects;
 
/**
 * <a href="http://my.oschina.net/arthor" class="referer" target="_blank">@author</a> canghailan 2012-01-13 23:06
 */
public class Fields {
 
    private static Map<FieldID, Field> fieldCache = new ConcurrentLRUCache<>();
    private static Map<FieldID, Method> getterCache = new ConcurrentLRUCache<>();
    private static ThreadLocal<FieldID> fieldID = new ThreadLocal<FieldID>() {
        protected FieldID initialValue() {
            return new FieldID();
        }
    };
    private static ThreadLocal<StringBuilder> buffer = new ThreadLocal<StringBuilder>() {
        protected StringBuilder initialValue() {
            return new StringBuilder();
        }
    };
 
    //################################################################################
 
    public static Field lookupField(Class<?> clazz, String name)
            throws NoSuchFieldException {
        assert clazz != null;
        // using cache
        FieldID id = fieldID.get().set(clazz, name);
        if (fieldCache.containsKey(id)) {
            return fieldCache.get(id);
        }
        // lookup and cache
        for (Class<?> clz = clazz; clz != null; clz = clz.getSuperclass()) {
            for (Field field : clz.getDeclaredFields()) {
                if (field.getName().equals(name)) {
                    fieldCache.put(new FieldID(clazz, name), field);
                    return field;
                }
            }
        }
        throw new NoSuchFieldException(clazz.getName() + "." + name);
    }
 
    //################################################################################
 
    public static String getterOrSetter(String getOrSet, String field) {
        // build get...|is...|set...
        StringBuilder buf = buffer.get();
        buf.setLength(0);
        buf.append(getOrSet).append(field)
                .setCharAt(getOrSet.length(), Character.toUpperCase(field.charAt(0)));
        return buf.toString();
    }
 
    @SuppressWarnings("unchecked")
    public static <T> T get(Object object, String field)
            throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
        // using cache
        FieldID id = fieldID.get().set(object.getClass(), field);
        Method getter = getterCache.get(id);
        if (getter != null) {
            return (T) getter.invoke(object);
        }
        if (getterCache.containsKey(id)) {
            throw new NoSuchMethodException("getter: " + object.getClass().getName() + "." + field);
        }
 
        // lookup get and cache
        getter = Methods.lookupMethod(object.getClass(), getterOrSetter("get", field));
        if (getter != null) {
            getterCache.put(new FieldID(object.getClass(), field), getter);
            return (T) getter.invoke(object);
        }
        // maybe boolean, lookup is and cache
        if (field.startsWith("is") && Character.isUpperCase(field.charAt("is".length()))) {
            getter = Methods.lookupMethod(object.getClass(),
                    getterOrSetter("is", field.substring("is".length())));
        } else {
            getter = Methods.lookupMethod(object.getClass(),
                    getterOrSetter("is", field));
        }
        if (getter != null) {
            getterCache.put(new FieldID(object.getClass(), field), getter);
            return (T) getter.invoke(object);
        }
        // no such method, cache
        getterCache.put(new FieldID(object.getClass(), field), null);
        throw new NoSuchMethodException("getter: " + object.getClass().getName() + "." + field);
    }
 
    public static void set(Object object, String field, Object value)
            throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
        Methods.invoke(object, getterOrSetter("set", field), value);
    }
 
    //################################################################################
 
    @SuppressWarnings("unchecked")
    public static <T> T directGet(Object object, String fieldName)
            throws NoSuchFieldException, IllegalAccessException {
        Field field = lookupField(object.getClass(), fieldName);
        boolean accessible = field.isAccessible();
        field.setAccessible(true);
        Object value = field.get(object);
        field.setAccessible(accessible);
        return (T) value;
    }
 
    public static void directSet(Object object, String fieldName, Object value)
            throws NoSuchFieldException, IllegalAccessException {
        Field field = lookupField(object.getClass(), fieldName);
        boolean accessible = field.isAccessible();
        field.setAccessible(true);
        field.set(object, value);
        field.setAccessible(accessible);
    }
 
    //################################################################################
 
    public static void copy(Object src, Object dst, String... fields)
            throws NoSuchFieldException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        if (src.getClass().equals(dst.getClass())) {
            for (String name : fields) {
                Field field = lookupField(src.getClass(), name);
                boolean accessible = field.isAccessible();
                field.setAccessible(true);
                field.set(dst, field.get(dst));
                field.setAccessible(accessible);
            }
        } else {
            for (String name : fields) {
                set(dst, name, get(src, name));
            }
        }
    }
 
    public static <T> void copy(T src, T dst) throws IllegalAccessException {
        for (Class<?> clz = src.getClass(); clz != null; clz = clz.getSuperclass()) {
            for (Field field : clz.getDeclaredFields()) {
                boolean accessible = field.isAccessible();
                field.setAccessible(true);
                field.set(dst, field.get(dst));
                field.setAccessible(accessible);
            }
        }
    }
 
    //################################################################################
 
    private static class FieldID {
        Class<?> clazz;
        String name;
 
        FieldID() {
        }
 
        FieldID(Class<?> clazz, String name) {
            this.clazz = clazz;
            this.name = name;
        }
 
        FieldID set(Class<?> clazz, String name) {
            this.clazz = clazz;
            this.name = name;
            return this;
        }
 
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o instanceof FieldID) {
                FieldID fieldID = (FieldID) o;
                return Objects.equals(clazz, fieldID.clazz) &&
                        Objects.equals(name, fieldID.name);
            }
            return false;
        }
 
        @Override
        public int hashCode() {
            int result = Objects.hashCode(clazz);
            result = 31 * result + Objects.hashCode(name);
            return result;
        }
    }
}

如果我没猜错，你应该指的是反射方法时overload的处理吧。我在Methods里处理了这种情况。

?

1	`public` `static` `Method lookupMethod(Class<?> clazz, String name, Object... params)`

同名方法选择最精确的方法。

就我的了解，反射的时候int之类的都应该是boxing为Integer等包装类型处理的。

老大，这个。。这是样的，我只需要操作属性，属性实例都是数据表实体类，所包含的类型无非就字符串和数值类型，如 int,double,string，对其进行赋值操作，但是提供的set(obj)方法如果对引用类型赋值的时候是会报错的，因为诸如int和double类型无法隐式转换成object 。我希望的是，能否通过一种方法，（前提是不用if...else判断类型字符串），自动转换成该属性赋值所需要的类型。。

创建时间：	2015/8/25 0:01
来源：	http://www.oschina.net/question/224858_36864?sort=time

关于java反射为属性赋值的问题 - 开源中国社区

引用来自“canghailan”的答案